package com.kgis.kp.dao.impl;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.hibernate.Criteria;
import org.hibernate.Hibernate;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.hibernate.metadata.ClassMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.SessionFactoryUtils;

import com.kgis.kp.common.util.Assertion;
import com.kgis.kp.common.util.ReflectionUtils;
import com.kgis.kp.dao.HibernateDataAccessObject;


/**
 * 
 */
public class HibernateDataAccessObjectImpl<T, ID extends Serializable> implements HibernateDataAccessObject<T, Serializable>
{
    protected Logger logger = LoggerFactory.getLogger(getClass());
    protected Class<T> entityClass;
    private HibernateTemplate hibernateTemplate;

    protected HibernateTemplate getHibernateTemplate()
    {
        return hibernateTemplate;
    }

    /**
     * 通过子类的泛型定义取得对象类型Class. eg. public class UserDao extends SimpleHibernateDao<User, Long>
     */
    public HibernateDataAccessObjectImpl()
    {
        this.entityClass = ReflectionUtils.getSuperClassGenricType(getClass());
    }

    public HibernateDataAccessObjectImpl(Class<T> entityClass)
    {
        this.entityClass = entityClass;
    }

    /**
     * 执行HQL进行批量修改/删除操作.
     * 
     * @param values
     *            数量可变的参数,按顺序绑定.
     * @return 更新记录数.
     */
    @Override
    public int batchExecute(String hql, Object... values)
    {
        return createQuery(hql, values).executeUpdate();
    }

    /**
     * 执行HQL进行批量修改/删除操作.
     * 
     * @param values
     *            命名参数,按名称绑定.
     * @return 更新记录数.
     */
    @Override
    public int batchExecute(String hql, Map<String, ?> values)
    {
        return createQuery(hql, values).executeUpdate();
    }

    @Override
    public void clear()
    {
        getHibernateTemplate().clear();
    }

    /**
     * 根据Criterion条件创建Criteria. 与find()函数可进行更加灵活的操作.
     * 
     * @param criterions
     *            数量可变的Criterion.
     */
    @Override
    public Criteria createCriteria(Criterion... criterions)
    {
        Criteria criteria = getSession().createCriteria(entityClass);
        for (Criterion c : criterions)
        {
            criteria.add(c);
        }
        return criteria;
    }

    /**
     * 根据查询HQL与参数列表创建Query对象. 与find()函数可进行更加灵活的操作.
     * 
     * @param values
     *            数量可变的参数,按顺序绑定.
     */
    @Override
    public Query createQuery(String queryString, Object... values)
    {
        Assertion.hasText(queryString, "queryString不能为空");
        Query query = getSession().createQuery(queryString);
        if (values != null)
        {
            for (int i = 0; i < values.length; i++)
            {
                query.setParameter(i, values[i]);
            }
        }
        return query;
    }

    /**
     * 根据查询HQL与参数列表创建Query对象. 与find()函数可进行更加灵活的操作.
     * 
     * @param values
     *            命名参数,按名称绑定.
     */
    @Override
    public Query createQuery(String queryString, Map<String, ?> values)
    {
        Assertion.hasText(queryString, "queryString不能为空");
        Query query = getSession().createQuery(queryString);
        if (values != null)
        {
            query.setProperties(values);
        }
        return query;
    }

    /**
     * 删除对象.
     */
    @Override
    public void delete(Object o)
    {
        getHibernateTemplate().delete(o);
    }

    /**
     * 根据ID删除对象.
     */
    @Override
    public void deleteById(Class<T> entityClass, Serializable id)
    {
        delete(get(entityClass, id));
    }

    /**
     * 按id删除对象.
     */
    @Override
    public void deleteById(Serializable id)
    {
        Assertion.notNull(id, "id不能为空");
        delete(get(id));
        logger.debug("delete entity {},id is {}", entityClass.getSimpleName(), id);

    }

    /**
     * 为Query添加distinct transformer. 预加载关联对象的HQL会引起主对象重复, 需要进行distinct处理.
     */
    @Override
    public Query distinct(Query query)
    {
        query.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        return query;
    }

    /**
     * 为Criteria添加distinct transformer. 预加载关联对象的HQL会引起主对象重复, 需要进行distinct处理.
     */
    @Override
    public Criteria distinct(Criteria criteria)
    {
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        return criteria;
    }

    /**
     * 按HQL查询对象列表.
     * 
     * @param values
     *            数量可变的参数,按顺序绑定.
     */
    @SuppressWarnings("unchecked")
	@Override
    public <X> List<X> find(String hql, Object... values)
    {
        return createQuery(hql, values).list();
    }

    /**
     * 按HQL查询对象列表.
     * 
     * @param values
     *            命名参数,按名称绑定.
     */
    @SuppressWarnings("unchecked")
	@Override
    public <X> List<X> find(String hql, Map<String, ?> values)
    {
        return createQuery(hql, values).list();
    }

    /**
     * 按Criteria查询对象列表.
     * 
     * @param criterions
     *            数量可变的Criterion.
     */
    @SuppressWarnings("unchecked")
	@Override
    public List<T> find(Criterion... criterions)
    {
        return createCriteria(criterions).list();
    }

    /**
     * 按属性查找对象列表, 匹配方式为相等.
     */
    @Override
    public List<T> findBy(String propertyName, Object value)
    {
        Assertion.hasText(propertyName, "propertyName不能为空");
        Criterion criterion = Restrictions.eq(propertyName, value);
        return find(criterion);
    }

    /**
     * 按HQL查询唯一对象.
     * 
     * @param values
     *            数量可变的参数,按顺序绑定.
     */
    @SuppressWarnings("unchecked")
	@Override
    public <X> X findUnique(String hql, Object... values)
    {
        return (X) createQuery(hql, values).uniqueResult();
    }

    /**
     * 按HQL查询唯一对象.
     * 
     * @param values
     *            命名参数,按名称绑定.
     */
    @SuppressWarnings("unchecked")
	@Override
    public <X> X findUnique(String hql, Map<String, ?> values)
    {
        return (X) createQuery(hql, values).uniqueResult();
    }

    /**
     * 按Criteria查询唯一对象.
     * 
     * @param criterions
     *            数量可变的Criterion.
     */
    @SuppressWarnings("unchecked")
	@Override
    public T findUnique(Criterion... criterions)
    {
        return (T) createCriteria(criterions).uniqueResult();
    }

    /**
     * 按属性查找唯一对象, 匹配方式为相等.
     */
    @SuppressWarnings("unchecked")
	@Override
    public T findUniqueBy(String propertyName, Object value)
    {
        Assertion.hasText(propertyName, "propertyName不能为空");
        Criterion criterion = Restrictions.eq(propertyName, value);
        return (T) createCriteria(criterion).uniqueResult();
    }

    @Override
    public void flush()
    {
        getHibernateTemplate().flush();
    }

    /**
     * 根据ID获取对象. 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常.
     */
    @Override
    public T get(Class<T> entityClass, Serializable id)
    {
        return (T) getHibernateTemplate().get(entityClass, id);
    }

    /**
     * 按id获取对象.
     */
    @Override
    public T get(Serializable id)
    {
        Assertion.notNull(id, "id不能为空");
        return (T) getHibernateTemplate().load(entityClass, id);
    }

    /**
     * 按id列表获取对象列表.
     */
    @Override
    public List<T> get(Collection<Serializable> ids)
    {
        return find(Restrictions.in(getIdName(), ids));
    }

    /**
     * 获取全部对象.
     */
    @Override
    public List<T> getAll(Class<T> entityClass)
    {
        return getHibernateTemplate().loadAll(entityClass);
    }

    /**
     * 获取全部对象.
     */
    @Override
    public List<T> getAll()
    {
        return find();
    }

    /**
     * 获取全部对象, 支持按属性行序.
     */
    @SuppressWarnings("unchecked")
	@Override
    public List<T> getAll(String orderByProperty, boolean isAsc)
    {
        Criteria c = createCriteria();
        if (isAsc)
        {
            c.addOrder(Order.asc(orderByProperty));
        }
        else
        {
            c.addOrder(Order.desc(orderByProperty));
        }
        return c.list();
    }

    /**
     * 取得对象的主键名.
     */
    @Override
    public String getIdName()
    {
        ClassMetadata meta = getSessionFactory().getClassMetadata(entityClass);
        return meta.getIdentifierPropertyName();
    }

    /**
     * 初始化对象. 使用load()方法得到的仅是对象Proxy, 在传到View层前需要进行初始化. 如果传入entity, 则只初始化entity的直接属性,但不会初始化延迟加载的关联集合和属性. 如需初始化关联属性,需执行:
     * Hibernate.initialize(user.getRoles())，初始化User的直接属性和关联集合.
     * Hibernate.initialize(user.getDescription())，初始化User的直接属性和延迟加载的Description属性.
     */
    @Override
    public void initProxyObject(Object proxy)
    {
        Hibernate.initialize(proxy);
    }

    /**
     * 判断对象的属性值在数据库内是否唯一. 在修改对象的情景下,如果属性新修改的值(value)等于属性原来的值(orgValue)则不作比较.
     */
    @Override
    public boolean isPropertyUnique(String propertyName, Object newValue, Object oldValue)
    {
        if (newValue == null || newValue.equals(oldValue))
        {
            return true;
        }
        Object object = findUniqueBy(propertyName, newValue);
        return (object == null);
    }

    /**
     * 保存对象.
     */
    @Override
    public void merge(Object o)
    {
        getHibernateTemplate().merge(o);
    }

    /**
     * 保存对象.
     */
    @SuppressWarnings("unchecked")
	@Override
    public ID saveObject(Object o)
    {
        return (ID) getHibernateTemplate().save(o);
    }

    /**
     * 保存对象.
     */
    @SuppressWarnings("unchecked")
	@Override
    public ID saveOrUpdate(Object o)
    {
        return (ID) getHibernateTemplate().save(o);
    }

    /**
     * 更新对象.
     */
    @Override
    public void update(Object o)
    {
        getHibernateTemplate().update(o);
    }

    protected Session getSession()
    {
        return getSession(this.hibernateTemplate.isAllowCreate());
    }

    protected Session getSession(boolean allowCreate)
    {
        return (!allowCreate ? SessionFactoryUtils.getSession(getSessionFactory(), false) : SessionFactoryUtils
            .getSession(getSessionFactory(), this.hibernateTemplate.getEntityInterceptor(), this.hibernateTemplate
                .getJdbcExceptionTranslator()));
    }

    protected SessionFactory getSessionFactory()
    {
        return (this.hibernateTemplate != null ? this.hibernateTemplate.getSessionFactory() : null);
    }

    public void setHibernateTemplate(HibernateTemplate hibernateTemplate)
    {
        this.hibernateTemplate = hibernateTemplate;
    }
}